home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 10 / AACD 10.iso / AACD / Resources / Online / Term / Extras / Source / term-source.lha / TransferPanel.c < prev    next >
C/C++ Source or Header  |  1996-10-20  |  15KB  |  718 lines
  1. /*
  2. **    TransferPanel.c
  3. **
  4. **    File transfer control panel support routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. **
  9. **    :ts=4
  10. */
  11.  
  12. #ifndef _GLOBAL_H
  13. #include "Global.h"
  14. #endif
  15.  
  16. STATIC BOOL    StatusChanged        = FALSE;
  17. STATIC LONG    TransferInfoCount    = 0;
  18.  
  19. STATIC ULONG SAVE_DS ASM
  20. TransferListViewRender(REG(a0) struct Hook *UnusedHook,REG(a2) struct Node *Node,REG(a1) struct LVDrawMsg *Msg)
  21. {
  22.         /* We only know how to redraw lines. */
  23.  
  24.     if(Msg->lvdm_MethodID == LV_DRAW)
  25.     {
  26.         struct RastPort    *RPort;
  27.         LONG             Left,Top,Width,Height,
  28.                          FgPen,BgPen,
  29.                          Len,LabelLen;
  30.         STRPTR             String;
  31.         UWORD            *Pens;
  32.  
  33.         RPort    = Msg->lvdm_RastPort;
  34.  
  35.         Left    = Msg->lvdm_Bounds.MinX;
  36.         Top        = Msg->lvdm_Bounds.MinY;
  37.         Width    = Msg->lvdm_Bounds.MaxX - Msg->lvdm_Bounds.MinX + 1;
  38.         Height    = Msg->lvdm_Bounds.MaxY - Msg->lvdm_Bounds.MinY + 1;
  39.  
  40.         String    = Node->ln_Name;
  41.  
  42.         Pens    = Msg->lvdm_DrawInfo->dri_Pens;
  43.  
  44.             /* Determine the rendering pens. */
  45.  
  46.         if(Msg->lvdm_State == LVR_SELECTED)
  47.         {
  48.             FgPen = FILLTEXTPEN;
  49.             BgPen = FILLPEN;
  50.         }
  51.         else
  52.         {
  53.             FgPen = TEXTPEN;
  54.             BgPen = BACKGROUNDPEN;
  55.         }
  56.  
  57.         FgPen = Pens[FgPen];
  58.         BgPen = Pens[BgPen];
  59.  
  60.         SetABPenDrMd(RPort,BgPen,BgPen,JAM2);
  61.         RectFill(RPort,Left,Top,Left + 1,Top + Height - 1);
  62.  
  63.         Left    += 2;
  64.         Width    -= 2;
  65.  
  66.             /* Is this an error message? */
  67.  
  68.         if(*String++ == '*' && BgPen != Pens[HIGHLIGHTTEXTPEN])
  69.             FgPen = Pens[HIGHLIGHTTEXTPEN];
  70.  
  71.             /* Determine length of vanilla name. */
  72.  
  73.         LabelLen = strlen(String);
  74.  
  75.             /* Try to make it fit. */
  76.  
  77.         LabelLen = FitText(RPort,Width,String,LabelLen);
  78.  
  79.             /* Print the vanilla name if possible. */
  80.  
  81.         if(LabelLen)
  82.         {
  83.             Len = TextLength(RPort,String,LabelLen);
  84.  
  85.             SetAPen(RPort,FgPen);
  86.  
  87.             PlaceText(RPort,Left,Top,String,LabelLen);
  88.  
  89.             Left    += Len;
  90.             Width    -= Len;
  91.         }
  92.  
  93.             /* Fill the area to follow the vanilla name. */
  94.  
  95.         if(Width > 0)
  96.         {
  97.             SetAPen(RPort,BgPen);
  98.             FillBox(RPort,Left,Top,Width,Height);
  99.         }
  100.  
  101.             /* If the item happens to be disabled, draw the cross-hatch
  102.              * pattern across it.
  103.              */
  104.  
  105.         ListViewStateFill(Msg);
  106.  
  107.         return(LVCB_OK);
  108.     }
  109.     else
  110.         return(LVCB_UNKNOWN);
  111. }
  112.  
  113.     /* AddTransferInfo(STRPTR Message,...):
  114.      *
  115.      *    Add another entry to the transfer information list.
  116.      */
  117.  
  118. VOID
  119. AddTransferInfo(BOOL Error,STRPTR Message,...)
  120. {
  121.     UBYTE TempBuffer[256];
  122.     struct Node *Node;
  123.     va_list VarArgs;
  124.  
  125.     if(Kick30)
  126.     {
  127.         va_start(VarArgs,Message);
  128.         LimitedVSPrintf(sizeof(TempBuffer),&TempBuffer[1],Message,VarArgs);
  129.         va_end(VarArgs);
  130.  
  131.         if(Error)
  132.             TempBuffer[0] = '*';
  133.         else
  134.             TempBuffer[0] = ' ';
  135.     }
  136.     else
  137.     {
  138.         va_start(VarArgs,Message);
  139.         LimitedVSPrintf(sizeof(TempBuffer),TempBuffer,Message,VarArgs);
  140.         va_end(VarArgs);
  141.     }
  142.  
  143.     if(Node = CreateNode(TempBuffer))
  144.     {
  145.         LT_SetAttributes(TransferHandle,GAD_TRANSFER_INFORMATION_LIST,
  146.             GTLV_Labels,    ~0,
  147.         TAG_DONE);
  148.  
  149.         if(TransferInfoCount == 100)
  150.         {
  151.             FreeVecPooled(RemHead(&TransferInfoList));
  152.  
  153.             TransferInfoCount = 99;
  154.         }
  155.  
  156.         AddTail(&TransferInfoList,Node);
  157.  
  158.         LT_SetAttributes(TransferHandle,GAD_TRANSFER_INFORMATION_LIST,
  159.             GTLV_Labels,                &TransferInfoList,
  160.             Kick30 ? GTLV_MakeVisible : GTLV_Top,    TransferInfoCount,
  161.         TAG_DONE);
  162.  
  163.         TransferInfoCount++;
  164.     }
  165. }
  166.  
  167. STATIC struct LayoutHandle *
  168. CreateTheTransferPanel(VOID)
  169. {
  170.     STATIC struct Hook ListViewHook;
  171.  
  172.     struct LayoutHandle *Handle;
  173.  
  174.     InitHook(&ListViewHook,(HOOKFUNC)TransferListViewRender,NULL);
  175.  
  176.     if(Handle = LT_CreateHandleTags(Window ? Window->WScreen : NULL,
  177.         LAHN_LocaleHook,&LocaleHook,
  178.     TAG_DONE))
  179.     {
  180.         STATIC LONG LabelGroups[5][2] =
  181.         {
  182.             MSG_TRANSFERPANEL_FILE_TXT,
  183.                 MSG_TRANSFERPANEL_COMPLETION_TIME_TXT,
  184.  
  185.             MSG_TRANSFERPANEL_FILE_SIZE_TXT,
  186.                 MSG_TRANSFERPANEL_BLOCKS_TRANSFERRED_TXT,
  187.  
  188.             MSG_TRANSFERPANEL_ESTIMATED_TIME_TXT,
  189.                 MSG_TRANSFERPANEL_ELAPSED_TIME_TXT,
  190.  
  191.             MSG_TRANSFERPANEL_CHARACTERS_PER_SECOND_TXT,
  192.                 MSG_TRANSFERPANEL_BLOCK_SIZE_TXT,
  193.  
  194.             MSG_TRANSFERPANEL_NUMBER_OF_ERRORS_TXT,
  195.                 MSG_TRANSFERPANEL_NUMBER_OF_TIMEOUTS_TXT,
  196.         };
  197.  
  198.         STATIC WORD Pens[] =
  199.         {
  200.             BLOCKPEN,
  201.             TEXTPEN,
  202.             BACKGROUNDPEN,
  203.             FILLTEXTPEN,
  204.             FILLPEN,
  205.             HIGHLIGHTTEXTPEN
  206.         };
  207.  
  208.         LONG len,max,i,j,MaxPen;
  209.  
  210.         max = LT_LabelChars(Handle,LocaleString(MSG_TRANSFERPANEL_PROTOCOL_TXT));
  211.         len = LT_LabelChars(Handle,LocaleString(MSG_TRANSFERPANEL_INFORMATION_GAD));
  212.  
  213.         if(len > max)
  214.             max = len;
  215.  
  216.         for(i = 0 ; i < 5 ; i++)
  217.         {
  218.             for(j = LabelGroups[i][0] ; j <= LabelGroups[i][1] ; j++)
  219.             {
  220.                 len = LT_LabelChars(Handle,LocaleString(j));
  221.  
  222.                 if(len > max)
  223.                     max = len;
  224.             }
  225.         }
  226.  
  227.         for(i = 0, MaxPen = -1 ; i < NUM_ELEMENTS(Pens) ; i++)
  228.         {
  229.             if(Handle->DrawInfo->dri_Pens[Pens[i]] > MaxPen)
  230.                 MaxPen = Handle->DrawInfo->dri_Pens[Pens[i]];
  231.         }
  232.  
  233.         LT_New(Handle,
  234.             LA_Type,VERTICAL_KIND,
  235.         TAG_DONE);
  236.         {
  237.             LT_New(Handle,
  238.                 LA_Type,VERTICAL_KIND,
  239.             TAG_DONE);
  240.             {
  241.                 LT_New(Handle,
  242.                     LA_Type,VERTICAL_KIND,
  243.                 TAG_DONE);
  244.                 {
  245.                     UBYTE    LocalBuffer[60];
  246.                     WORD    Len;
  247.  
  248.                     strcpy(LocalBuffer,FilePart(LastXprLibrary));
  249.  
  250.                     if((Len = strlen(LocalBuffer)) > 3)
  251.                     {
  252.                         UBYTE ProtocolBuffer[60];
  253.  
  254.                         strcpy(ProtocolBuffer,&LocalBuffer[3]);
  255.  
  256.                         for(i = 0 ; i < Len - 3 ; i++)
  257.                         {
  258.                             if(ProtocolBuffer[i] == '.')
  259.                             {
  260.                                 ProtocolBuffer[i] = 0;
  261.  
  262.                                 break;
  263.                             }
  264.                         }
  265.  
  266.                         ProtocolBuffer[0] = ToUpper(ProtocolBuffer[0]);
  267.  
  268.                         LimitedSPrintf(sizeof(LocalBuffer),LocalBuffer,"[%s]",ProtocolBuffer);
  269.                     }
  270.                     else
  271.                         strcpy(LocalBuffer,"-");
  272.  
  273.                     LT_New(Handle,
  274.                         LA_Type,            TEXT_KIND,
  275.                         LA_LabelID,            MSG_TRANSFERPANEL_PROTOCOL_TXT,
  276.                         LA_LabelChars,        max,
  277.                         LA_Chars,            50,
  278.                         LA_ID,                GAD_TRANSFER_PROTOCOL,
  279.                         GTTX_Text,            LocalBuffer,
  280.                         GTTX_CopyText,        TRUE,
  281.                         GTTX_Border,        TRUE,
  282.                     TAG_DONE);
  283.  
  284.                     LT_New(Handle,
  285.                         LA_Type,            LISTVIEW_KIND,
  286.                         LA_LabelID,            MSG_TRANSFERPANEL_INFORMATION_GAD,
  287.                         LA_LabelChars,        max,
  288.                         LA_LabelPlace,        PLACE_Left,
  289.                         LA_ID,                GAD_TRANSFER_INFORMATION_LIST,
  290.                         LA_Chars,            50,
  291.                         LALV_Lines,            2,
  292.                         LALV_MaxGrowY,        10,
  293.                         LALV_CursorKey,        TRUE,
  294.                         GTLV_ReadOnly,        TRUE,
  295.                         GTLV_CallBack,        &ListViewHook,
  296.                         GTLV_MaxPen,        MaxPen,
  297.                     TAG_DONE);
  298.  
  299.                     LT_New(Handle,
  300.                         LA_Type,            XBAR_KIND,
  301.                     TAG_DONE);
  302.  
  303.                     LT_New(Handle,
  304.                         LA_Type,            BOX_KIND,
  305.                         LA_ID,                GAD_TRANSFER_FILE,
  306.                         LA_Chars,            50,
  307.                         LA_LabelChars,        max,
  308.                         LABX_FirstLabel,    MSG_TRANSFERPANEL_FILE_TXT,
  309.                         LABX_LastLabel,        MSG_TRANSFERPANEL_COMPLETION_TIME_TXT,
  310.                         LABX_ReserveSpace,    TRUE,
  311.                     TAG_DONE);
  312.  
  313.                     LT_New(Handle,
  314.                         LA_Type,            XBAR_KIND,
  315.                     TAG_DONE);
  316.  
  317.                     LT_EndGroup(Handle);
  318.                 }
  319.  
  320.                 LT_New(Handle,
  321.                     LA_Type,HORIZONTAL_KIND,
  322.                 TAG_DONE);
  323.                 {
  324.                     LT_New(Handle,
  325.                         LA_Type,VERTICAL_KIND,
  326.                     TAG_DONE);
  327.                     {
  328.                         LT_New(Handle,
  329.                             LA_Type,            BOX_KIND,
  330.                             LA_ID,                GAD_TRANSFER_SIZE,
  331.                             LA_LabelChars,        max,
  332.                             LA_Chars,            15,
  333.                             LABX_FirstLabel,    MSG_TRANSFERPANEL_FILE_SIZE_TXT,
  334.                             LABX_LastLabel,        MSG_TRANSFERPANEL_BLOCKS_TRANSFERRED_TXT,
  335.                             LABX_ReserveSpace,    TRUE,
  336.                             LABX_AlignText,        ALIGNTEXT_Right,
  337.                         TAG_DONE);
  338.  
  339.                         LT_New(Handle,
  340.                             LA_Type,            BOX_KIND,
  341.                             LA_LabelChars,        max,
  342.                             LA_ID,                GAD_TRANSFER_TOTALTIME,
  343.                             LABX_FirstLabel,    MSG_TRANSFERPANEL_ESTIMATED_TIME_TXT,
  344.                             LABX_LastLabel,        MSG_TRANSFERPANEL_ELAPSED_TIME_TXT,
  345.                             LABX_ReserveSpace,    TRUE,
  346.                             LABX_AlignText,        ALIGNTEXT_Right,
  347.                         TAG_DONE);
  348.  
  349.                         LT_EndGroup(Handle);
  350.                     }
  351.  
  352.                     LT_New(Handle,
  353.                         LA_Type,                VERTICAL_KIND,
  354.                         LAGR_LastAttributes,    TRUE,
  355.                     TAG_DONE);
  356.                     {
  357.                         LT_New(Handle,
  358.                             LA_Type,            BOX_KIND,
  359.                             LA_ID,                GAD_TRANSFER_SECONDS,
  360.                             LA_LabelChars,        max,
  361.                             LA_Chars,            15,
  362.                             LABX_FirstLabel,    MSG_TRANSFERPANEL_CHARACTERS_PER_SECOND_TXT,
  363.                             LABX_LastLabel,        MSG_TRANSFERPANEL_BLOCK_SIZE_TXT,
  364.                             LABX_ReserveSpace,    TRUE,
  365.                             LABX_AlignText,        ALIGNTEXT_Right,
  366.                         TAG_DONE);
  367.  
  368.                         LT_New(Handle,
  369.                             LA_Type,            BOX_KIND,
  370.                             LA_ID,                GAD_TRANSFER_ERRORS,
  371.                             LA_LabelChars,        max,
  372.                             LABX_FirstLabel,    MSG_TRANSFERPANEL_NUMBER_OF_ERRORS_TXT,
  373.                             LABX_LastLabel,        MSG_TRANSFERPANEL_NUMBER_OF_TIMEOUTS_TXT,
  374.                             LABX_ReserveSpace,    TRUE,
  375.                             LABX_AlignText,        ALIGNTEXT_Right,
  376.                         TAG_DONE);
  377.  
  378.                         LT_EndGroup(Handle);
  379.                     }
  380.  
  381.                     LT_EndGroup(Handle);
  382.                 }
  383.  
  384.                 LT_New(Handle,
  385.                     LA_Type,HORIZONTAL_KIND,
  386.                 TAG_DONE);
  387.                 {
  388.                     LT_New(Handle,
  389.                         LA_Type,XBAR_KIND,
  390.                     TAG_DONE);
  391.  
  392.                     LT_EndGroup(Handle);
  393.                 }
  394.  
  395.                 LT_New(Handle,
  396.                     LA_Type,        HORIZONTAL_KIND,
  397.                     LAGR_SameSize,    TRUE,
  398.                     LAGR_Spread,    TRUE,
  399.                 TAG_DONE);
  400.                 {
  401.                     LONG len1,len2,Maximum;
  402.  
  403.                     len1 = 4 + strlen(LocaleString(MSG_TRANSFERPANEL_DATA_TRANSFERRED_GAD)) + 1;
  404.                     len2 = 8 + strlen(LocaleString(MSG_TRANSFERPANEL_TIME_TO_GO_GAD)) + 1;
  405.  
  406.                     if(len1 > len2)
  407.                         Maximum = len1;
  408.                     else
  409.                         Maximum = len2;
  410.  
  411.                     if(Maximum < 30)
  412.                         Maximum = 30;
  413.  
  414.                     LT_New(Handle,
  415.                         LA_Type,        GAUGE_KIND,
  416.                         LA_Chars,        Maximum,
  417.                         LA_LabelPlace,    PLACE_In,
  418.                         LA_ID,            GAD_TRANSFER_PERCENT,
  419.                         LAGA_NoTicks,    TRUE,
  420.                         LAGA_InfoLength,len1,
  421.                     TAG_DONE);
  422.  
  423.                     LT_New(Handle,
  424.                         LA_Type,        GAUGE_KIND,
  425.                         LA_LabelPlace,    PLACE_In,
  426.                         LA_ID,            GAD_TRANSFER_TIME,
  427.                         LAGA_NoTicks,    TRUE,
  428.                         LAGA_InfoLength,len2,
  429.                     TAG_DONE);
  430.  
  431.                     LT_EndGroup(Handle);
  432.                 }
  433.  
  434.                 LT_EndGroup(Handle);
  435.             }
  436.  
  437.             LT_New(Handle,
  438.                 LA_Type,VERTICAL_KIND,
  439.             TAG_DONE);
  440.             {
  441.                 LT_New(Handle,
  442.                     LA_Type,        XBAR_KIND,
  443.                     LAXB_FullSize,    TRUE,
  444.                 TAG_DONE);
  445.  
  446.                 LT_EndGroup(Handle);
  447.             }
  448.  
  449.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  450.                 LAGR_Spread,TRUE,
  451.             TAG_DONE);
  452.             {
  453.                 LT_New(Handle,
  454.                     LA_Type,        BUTTON_KIND,
  455.                     LA_LabelID,        MSG_TRANSFERPANEL_SKIP_CURRENT_FILE_GAD,
  456.                     LA_ID,            GAD_TRANSFER_SKIP,
  457.                     LABT_ExtraFat,    TRUE,
  458.                 TAG_DONE);
  459.  
  460.                 LT_New(Handle,
  461.                     LA_Type,        BUTTON_KIND,
  462.                     LA_LabelID,        MSG_TRANSFERPANEL_ABORT_CURRENT_FILE_GAD,
  463.                     LA_ID,            GAD_TRANSFER_ABORT_FILE,
  464.                     LABT_ExtraFat,    TRUE,
  465.                 TAG_DONE);
  466.  
  467.                 LT_New(Handle,
  468.                     LA_Type,        BUTTON_KIND,
  469.                     LA_LabelID,        MSG_TRANSFERPANEL_ABORT_ENTIRE_TRANSFER_GAD,
  470.                     LA_ID,            GAD_TRANSFER_ABORT,
  471.                     LABT_EscKey,    TRUE,
  472.                     LABT_ExtraFat,    TRUE,
  473.                 TAG_DONE);
  474.  
  475.                 LT_EndGroup(Handle);
  476.             }
  477.  
  478.             LT_EndGroup(Handle);
  479.         }
  480.     }
  481.  
  482.     return(Handle);
  483. }
  484.  
  485.     /* TransferPanel(STRPTR Title):
  486.      *
  487.      *    Open the transfer window.
  488.      */
  489.  
  490. BOOL
  491. TransferPanel(STRPTR Title)
  492. {
  493.     if(TransferWindow)
  494.         return(TRUE);
  495.     else
  496.     {
  497.         WORD CurrentStatus;
  498.  
  499.         TransferFailed = TransferAborted = FALSE;
  500.  
  501.         CurrentStatus = GetStatus();
  502.  
  503.         if(CurrentStatus != STATUS_DOWNLOAD && CurrentStatus != STATUS_UPLOAD)
  504.         {
  505.             PushStatus(STATUS_DOWNLOAD);
  506.             StatusChanged = TRUE;
  507.         }
  508.  
  509.         if(TransferHandle = CreateTheTransferPanel())
  510.         {
  511.             LONG WindowLeft,WindowTop,IgnoreWidth,IgnoreHeight;
  512.  
  513.             TransferZoomed = FALSE;
  514.  
  515.             GetWindowInfo(WINDOW_FILETRANSFER,&WindowLeft,&WindowTop,&IgnoreWidth,&IgnoreHeight,0,0);
  516.  
  517.             if(TransferWindow = LT_Build(TransferHandle,
  518.                 LAWN_TitleText,        TransferWindowTitle = Title,
  519.                 LAWN_HelpHook,        &GuideHook,
  520.                 LAWN_Zoom,            TRUE,
  521.                 LAWN_Left,            WindowLeft,
  522.                 LAWN_Top,            WindowTop,
  523.                 LAWN_Parent,        Window,
  524.                 LAWN_LimitWidth,    WindowWidth,
  525.                 LAWN_LimitHeight,    WindowHeight,
  526.                 WA_DepthGadget,        TRUE,
  527.                 WA_DragBar,            TRUE,
  528.                 WA_RMBTrap,            TRUE,
  529.             TAG_DONE))
  530.             {
  531.                 BOOL    Activate,Move;
  532.                 LONG    i;
  533.  
  534.                 GuideContext(CONTEXT_TRANSFER);
  535.  
  536.                 if(Config->MiscConfig->AlertMode == ALERT_SCREEN || Config->MiscConfig->AlertMode == ALERT_BEEP_SCREEN)
  537.                     Move = Activate = TRUE;
  538.                 else
  539.                 {
  540.                     ULONG IntuiLock = LockIBase(NULL);
  541.  
  542.                     Activate = Move = FALSE;
  543.  
  544.                     if(IntuitionBase->ActiveScreen == Screen)
  545.                         Activate = TRUE;
  546.                     else
  547.                     {
  548.                         if(IntuitionBase->ActiveWindow && IntuitionBase->ActiveWindow->UserPort && IntuitionBase->ActiveWindow->UserPort->mp_Flags == PA_SIGNAL && IntuitionBase->ActiveWindow->UserPort->mp_SigTask == FindTask(NULL))
  549.                             Activate = TRUE;
  550.                     }
  551.  
  552.                     UnlockIBase(IntuiLock);
  553.                 }
  554.  
  555.                 if(Config->TransferConfig->TransferNotification == XFERNOTIFY_NEVER || Config->TransferConfig->TransferNotification == XFERNOTIFY_END)
  556.                     Move = Activate = FALSE;
  557.  
  558.                 if(Move)
  559.                 {
  560.                     if(TransferWindow->WScreen->LeftEdge > 0)
  561.                     {
  562.                         if(TransferWindow->WScreen->TopEdge > 0)
  563.                             MoveScreen(TransferWindow->WScreen,-TransferWindow->WScreen->LeftEdge,-TransferWindow->WScreen->TopEdge);
  564.                         else
  565.                             MoveScreen(TransferWindow->WScreen,-TransferWindow->WScreen->LeftEdge,0);
  566.                     }
  567.                     else
  568.                     {
  569.                         if(TransferWindow->WScreen->TopEdge > 0)
  570.                             MoveScreen(TransferWindow->WScreen,0,-TransferWindow->WScreen->TopEdge);
  571.                     }
  572.  
  573.                     WindowToFront(TransferWindow);
  574.  
  575.                     ScreenToFront(TransferWindow->WScreen);
  576.                 }
  577.  
  578.                 if(Activate)
  579.                     ActivateWindow(TransferWindow);
  580.  
  581.                 PushWindow(TransferWindow);
  582.  
  583.                 for(i = 0 ; i < 6 ; i++)
  584.                 {
  585.                     if(i < 4)
  586.                     {
  587.                         if(i < 2)
  588.                         {
  589.                             LT_SetAttributes(TransferHandle,GAD_TRANSFER_TOTALTIME,
  590.                                 LABX_Index,    i,
  591.                                 LABX_Text,    "-",
  592.                             TAG_DONE);
  593.  
  594.                             LT_SetAttributes(TransferHandle,GAD_TRANSFER_ERRORS,
  595.                                 LABX_Index,    i,
  596.                                 LABX_Text,    "-",
  597.                             TAG_DONE);
  598.                         }
  599.  
  600.                         LT_SetAttributes(TransferHandle,GAD_TRANSFER_FILE,
  601.                             LABX_Index,    i,
  602.                             LABX_Text,    "-",
  603.                         TAG_DONE);
  604.                     }
  605.  
  606.                     LT_SetAttributes(TransferHandle,GAD_TRANSFER_SIZE,
  607.                         LABX_Index,    i,
  608.                         LABX_Text,    "-",
  609.                     TAG_DONE);
  610.  
  611.                     LT_SetAttributes(TransferHandle,GAD_TRANSFER_SECONDS,
  612.                         LABX_Index,    i,
  613.                         LABX_Text,    "-",
  614.                     TAG_DONE);
  615.                 }
  616.  
  617.                 return(TRUE);
  618.             }
  619.  
  620.             LT_DeleteHandle(TransferHandle);
  621.  
  622.             TransferHandle = NULL;
  623.         }
  624.     }
  625.  
  626.     return(FALSE);
  627. }
  628.  
  629.     /* DeleteTransferPanel(BOOL WaitForPrompt):
  630.      *
  631.      *    Close the transfer window.
  632.      */
  633.  
  634. VOID
  635. DeleteTransferPanel(BOOL WaitForPrompt)
  636. {
  637.         /* Can any pending garbage. */
  638.  
  639.     if(TransferError)
  640.         FlushSerialRead();
  641.  
  642.         /* Wait for user to close the window? */
  643.  
  644.     if(WaitForPrompt && TransferHandle)
  645.     {
  646.         BOOL Done;
  647.  
  648.         LT_SetAttributes(TransferHandle,GAD_TRANSFER_SKIP,
  649.             GA_Disabled,TRUE,
  650.         TAG_DONE);
  651.  
  652.         LT_SetAttributes(TransferHandle,GAD_TRANSFER_ABORT_FILE,
  653.             GA_Disabled,TRUE,
  654.         TAG_DONE);
  655.  
  656.         Done = FALSE;
  657.  
  658.         do
  659.         {
  660.             if(Wait(PORTMASK(TransferWindow->UserPort) | SIG_BREAK) & SIG_BREAK)
  661.                 break;
  662.             else
  663.             {
  664.                 struct IntuiMessage    *Message;
  665.                 struct Gadget *MsgGadget;
  666.                 ULONG MsgClass;
  667.  
  668.                 while(Message = (struct IntuiMessage *)LT_GetIMsg(TransferHandle))
  669.                 {
  670.                     MsgClass    = Message->Class;
  671.                     MsgGadget    = (struct Gadget *)Message->IAddress;
  672.  
  673.                     LT_ReplyIMsg(Message);
  674.  
  675.                     if(MsgClass == IDCMP_GADGETUP && MsgGadget->GadgetID == GAD_TRANSFER_ABORT)
  676.                         Done = TRUE;
  677.                 }
  678.             }
  679.         }
  680.         while(!Done);
  681.     }
  682.  
  683.     TransferAbortState = 0;
  684.     TransferAbortCount = 0;
  685.  
  686.     TransferError = FALSE;
  687.  
  688.     if(FileTransferInfo)
  689.     {
  690.         FreeFileTransferInfo(FileTransferInfo);
  691.  
  692.         FileTransferInfo = NULL;
  693.     }
  694.  
  695.     if(StatusChanged)
  696.         PopStatus();
  697.  
  698.     if(TransferHandle)
  699.     {
  700.         PutWindowInfo(WINDOW_FILETRANSFER,TransferHandle->Window->LeftEdge,TransferHandle->Window->TopEdge,TransferHandle->Window->Width,TransferHandle->Window->Height);
  701.  
  702.         LT_DeleteHandle(TransferHandle);
  703.  
  704.         TransferHandle = NULL;
  705.     }
  706.  
  707.     if(!IsListEmpty(&TransferInfoList))
  708.     {
  709.         FreeList(&TransferInfoList);
  710.  
  711.         TransferInfoCount = 0;
  712.     }
  713.  
  714.     TransferWindow = NULL;
  715.  
  716.     ReleaseWindows();
  717. }
  718.